#include<iostream>
#include<list>
#include<map>
using namespace std;

#define forn(i,n) for(int i=0;i<(n);i++)
#define forsn(i,s,n) for(int i=(s);i<(n);i++)
#define forall(it,X) for(typeof((X).begin()) it=(X).begin();it!=(X).end();it++)

/* imprime los resultados */
void imprimir(const bool* clausulas, const bool* variables, int c, int v);

/* retorna el literal que más clausulas satisface */
int max_sat(map<int,int> sat);

int main(){
	int c; int v;
	while( cin >> c && cin >> v && c!=-1 && v!=-1 ){

		/* Convenciones en el codigo del algoritmo:
		 * las variables comienzan desde 1.
		 * Las clausulas comienzan desde 0.
		 * Los literales negados se representan con la variable negativa. */

		/* Mapea los literales a un arreglo de clausulas,
		 * donde una posicion tiene un valor verdadero
		 * si el literal puede satisfacer la clausula y falso si no */
		map<int,bool*> var;

		/* Mapea a cada literal a la cantidad de clausulas que satisface */
		map<int,int> sat;

		/* Inicializo las estructuras */
		forsn(i,1,v+1){
			var[i] = new bool[c];
			forn(j,c) var[i][j] = false;
			var[-i] = new bool[c];
			forn(j,c) var[-i][j] = false;
			sat[i] = 0;
			sat[-i] = 0;
		}

		/* Leo la entrada. Guardo para cada variable,
		 * la lista de clausulas a la que pertenece
		 * y actualizo la cantidad de clausulas que satisface.
		 * Las variables estan organizadas en un arreglo */

		forn(i,c){
			int j; cin >> j;
			forn(l,j){
				int k; cin >> k;
				var[k][i] = true;
				sat[k]++;
			}
		}
		
		/* Algoritmo */

		/* Guarda las clausulas satisfechas */
		bool satis[c]; forn(i,c) satis[i]=false;

		/* Guarda los estados de las variables */
		bool verda[v]; forn(i,c) verda[i]=false;

		/* Mientras exista una variable
		 * a la que todavía no le asigne un valor */
		while(!var.empty()){

			/* tomo del conjunto (los literales que no tienen un valor definido)
			 * el literal que satisface la mayor cantidad de clausulas */
			int max=max_sat(sat);

			/* pongo la variable en T/F,
			 * dependiendo de si el literal que maximiza
			 * es la variable negada o no */
			if(max>=0) verda[max-1]=true;
			else verda[-max-1]=false;

			/* para cada clausula satisfecha,
			 * la marco como tal y
			 * le aviso a los literales restantes que ya no pueden satisfacerla */

			forn(b,c) if(var[max][b]){
				satis[b]=true;
				forall(it,var) if((it->second)[b]){
					sat[it->first]--;
					(it->second)[b]=false;
				}
			}

			/* Como ya le asigne un valor a max,
			 * la elimino del conjunto de literales sin valor */
			var.erase(max);
			var.erase(-max);
			sat.erase(max);
			sat.erase(-max);
		}

		// imprimo el resultado
		imprimir(satis,verda,c,v);
	}
	return 0;
}

void imprimir(const bool* clausulas, const bool* variables, int c, int v){
	/* Cantidad de clausulas satisfechas */

	int n = 0;
	forn(i,c) if(clausulas[i]) n++;
	cout << n << endl;

	/* Clausulas satisfechas */

	cout << "C";
	forn(i,c) if(clausulas[i]) cout << " " << i+1;
	cout << endl;

	/* Variables verdaderas */

	cout << "V";
	forn(i,v) if(variables[i]) cout << " " << i+1;
	cout << endl;
}

int max_sat(map<int,int> sat){
	int max = 0; int var=sat.begin()->first;
	forall(it,sat) if(it->second>max){
		var=it->first; max=it->second;
	}
	return var;
}
